Just Call Me Internet/Just Call Me Internet.iso/com/bbs/server/connserv/connect/scripts/server.scr

Text File | 1994-07-21 | 15.5 KB | 722 lines

echo "ConNect ftp-Server Script"
echo "Version 1.4 vom 21/07/94, 13:58:46 Uhr"
echo "von Andreas Schrell @ RS (MausNet)"
echo "mit Tips von Wolfgang Wander @ HH2 (MausNet)"
echo "Benutzung in Firmen nur nach Zahlung von 30DM"
echo "siehe dazu README der Verteilung!"

# Changes:
# V 1.4 automatisches Abschalten zwischen 7:00 und 7:10
#       Zeitlog bei FAX
#       start3.txt -> start.txt umbenannt
# V 1.3 CARRIER-TEST
# V 1.2 FAX-CONNECT testweise aufgenommen
# V 1.2 Warteschleife etwas schneller

# !!!!!!! WICHTIG: Hier ggf. das Laufwerk/Pfad „ndern !!!!!!!!
ServerPfad="j:\\server"
MYFAXID=49202666889;

echo "Starte den Server..."

echo "Konstanten"

# Abh„ngig von der Verfgbarkeit eines Modems soll etwas unterschiedlich
# gearbeitet werden:
send "+++ATH"
if waitfor -t 1s "OK"; then
    Modem=1
    Extern=1
    echo ""
    echo "Modem erkannt -> Modem=1"
else
    Modem=0
    Extern=0
    echo "Modem nicht gefunden -> Modem=0"
fi

PublicPfad=$ServerPfad\\"pub"
MailPfad=$ServerPfad\\mail
if [ $Modem -eq 1 ]; then
    LogDatei=$ServerPfad\\log\\extern.log
    NummerFile=$ServerPfad\\log\\extern.num
    SuperName=$ServerPfad\\log\\extern.sup
else
    LogDatei=$ServerPfad\\log\\local.log
    NummerFile=$ServerPfad\\log\\local.num
    SuperName=$ServerPfad\\log\\local.sup
fi
UserPfad=$ServerPfad\\passwd
UserDatei=$UserPfad\\user.dat
TempPfad=$ServerPfad\\temp
Schrott=$TempPfad\\schrott
HOME=$PublicPfad
TIMEOUT="120s"

echo "Variablen"

BenutzerName="? ?"
AktuellerPfad=$PublicPfad

echo "Kleinkram definieren"

# Send-Funktion wegen Line-Feeds etc.
function Send {
    echo $1 >AUX:
}

# Log:
# Schreibt in Log-Datei und aufs Terminal
# Parameter: wie echo, aber in ""

function Log {
    echo $1 >> $LogDatei
    echo $1
}

# BefehlsLog:
# Tr„gt einen abgesetzten Befehl ins Logbuch ein
# Parameter:
#    $1: Befehl
#    $2: Commandline

function BefehlsLog {
    Log "-n [`datum`][$BenutzerName][$AktuellerPfad][$1][$2]"
}

# ReturnLog:
# Tr„gt den Rckgabewert eines Befehls ins Logbuch ein
# Parameter: 1
#    $1: Befehls-Returnwert

function ReturnLog {
    Log "[$1]"
}


# HoleEingabe:
# Um auszuschliežen, daž der Benutzer Zugriff auf den Rechner
# bekommt, indem er sowas wie 'cd tex `c:\\bin\\sh >AUX: <AUX:`'
# angibt, sind einige Zeichen fr den User tabu. CoSHy expandiert
# aber jedesmal bei Benutzung einer Variablen. Mittels eines Tips
# von Wolfgang gehe ich nun so vor:
# Variable(n) einlesen, ins Environment exportieren und dort mittels
# eines externen Programms (checkenv) testen. Falls Fehler auftraten,
# aus dem Environment mittels verbapp ins Logbuch schreiben. verbapp
# wird auch im Mail-System benutzt, um innerhalb von Mail alle Zeichen
# zuzulassen. Die Mailzeilen expandiert CoSHy nie.
# Parameter:
#    $1: Variablennamen (ggf. mehrere in "", ggf. auch "-n ...")

function HoleEingabe {
    if ! get $TIMEOUT $1; then
        Send "TimeOut"
        Log "TimeOut"
        hangup
        Befehl="quit"
        Commandline=""
        exit 1
    fi
    if [ $Modem -eq 1 ]; then
        if ! carrier; then
            Send "No carrier"
            Log "No carrier"
            hangup
            Befehl="quit"
            Commandline=""
            exit 1
        fi
    fi
    export $1
    if ! checkenv $1; then
        Send "!Unerlaubtes Zeichen"
        Log "[Unerlaubtes Zeichen:]"
        verbapp $LogDatei $1
        exit 1
    fi
    exit 0
}

# MyEval:
# Evaluiert ein Server-Kommando als CoSHy-Befehl
# und Eintrag ins Logbuch

function MyEval {
    BefehlsLog "$Befehl" "$Commandline"
        eval Server$Befehl
        Ret=$?
        if [ $Ret -ne 0 ]; then
            Send "!error"
        fi
    ReturnLog $Ret
}

# IfBefAlias:
# $Befehl duch $2 ersetzen, falls $Befehl=$1
# Parameter: 2
#    $1: Test
#    $2: Ersetzung
# GlobalIN:  $Befehl
# GlobalOUT: $Befehl

function IfBefAlias {
    if [ "$Befehl" = "$1" ]; then
        Befehl="$2"
    fi
}

# BefehlsAlias:
# Liste der Alias-Befehle abtesten

function BefehlsAlias {
    IfBefAlias     ls         dir
    IfBefAlias    ll        dir
    IfBefAlias    exit     quit
    IfBefAlias    bye        quit
    IfBefAlias    hangup    quit
    IfBefAlias    logout    quit
    IfBefAlias    logoff    quit
    IfBefAlias    find        search
    IfBefAlias    list        help
    IfBefAlias    "?"        help
}

echo "Befehlsinterpreter"

# BefehlsSchleife:
# Hauptschleife fr die Befehlseingabe

function BefehlsSchleife {
    Befehl=""
    while [ "$Befehl" != "quit" ]
    do
# Abbruch auf Serverseite erfragen
        readkey 1m TEST
        if [ "$TEST" = "q" ]; then
            TEST=""
            TimeOut
        fi
        send -n "$AktuellerPfad>"
        Commandline=""
        if HoleEingabe "Befehl Commandline"; then
            BefehlsAlias
            MyEval
        fi
    done
}

# Starttext ausgeben und Login-Info

function StartText {
    Send ""
    cat $ServerPfad\\text\\start.txt >AUX:
    Send ""
    Send "Die Benutzung ist nur eingetragenen Usern gestattet. ? = Hilfe."
    Send "Alle Eingaben werden zusammen mit Name und Zeit protokolliert."
    Send ""
}

# In der Login-Prozedur wird der Account getestet, ggf. abgelehnt,
# oder bei Erfolg die Befehlsschleife aufgerufen.

function Login {
    cd $PublicPfad
    UserNummer=-1
    UserName=""
    send -n "Dein Name: "
    if ! HoleEingabe BenutzerName; then
        exit 1
    fi
    Log "Login: $BenutzerName"
    getuser "$UserDatei" "\"$BenutzerName\""
    UserNummer=$?
    if [ $UserNummer -ne -1 ]; then
        send -n "Dein Passwort (ohne Anzeige): "
        if ! HoleEingabe "-n PassInput"; then
            exit 1
        fi
        testpass "$UserPfad\\$UserNummer.p" "\"$PassInput\""
        if [ $? -eq 0 ]; then
            Send ""
            Send ""
            read AnrufNummer < $NummerFile
            AnrufNummer=`expr $AnrufNummer + 1`
            echo $AnrufNummer > $NummerFile
            Send "Alles klar. Du bist der $AnrufNummer. Anrufer! Auf gehts..."
            if [ $AnrufNummer -eq 1 ]; then
                Send "Na endlich. Da ist ja der erste Anruf!!!!"
            fi
            if [ $AnrufNummer -eq 13 ]; then
                Send "13! Du hast Pech und musst beim Stammtisch einen ausgeben!"
            fi
            if [ $AnrufNummer -eq 100 ]; then
                Send "Gratulation zum 100.!"
            fi
            if [ $AnrufNummer -eq 1000 ]; then
                Send "Der 1000. Anrufer! Beachtlich!"
                Send "Das gibt ein Guiness vom naechsten..."
                echo "$BenutzerName" > $SuperName
            fi
            if [ $AnrufNummer -eq 1001 ]; then
                Send "Der 1001. Anrufer! Schon wieder Pech!"
                read SName <$SuperName
                Send "Du musst dem 1000. ein Guiness ausgeben."
                Send "Das war $SName."
            fi
            Send ""
            Log "Login akzeptiert. Nummer $AnrufNummer."
            BefehlsSchleife
            Log "Logout."
            exit 0
        else
            Log "Passwd: $PassInput"
            Send "Das wahr wohl nix..."
            Log "Login abgelehnt."
            exit 1
        fi
    else
        Send "Dich kenn ich nich!"
        Log "Benutzer unbekannt."
        exit 1
    fi
}


echo "Server-Befehle"

# In $AktuellerPfad wird immer der vollst„ndig expandierte Pfad gehalten.
# Jetzt kann ein cd erstmal ausgefhrt werden. Ein externes Programm testet,
# ob der erreichte Pfad noch gltig ist (innerhalb von $PublicPfad liegt).
# Wenn nicht, wird der alte Pfad restauriert, sonst ist alles klar.

function Servercd {
    AlterPfad="$AktuellerPfad"
     cd $AktuellerPfad\\$Commandline >$Schrott
    Ret=$?
    # Wenn kein Parameter, dann PublicPfad.
    if [ "$Commandline" = "" ]; then
        Ret=1
    fi
    if [ $Ret -ne 0 ]; then
        cd $PublicPfad\\$Commandline >$Schrott
        Ret=$?
    fi
    if [ $Ret -ne 0 ]; then
        Send "!Ungltiges Verzeichnis"
        Log "-n [Ungltiges Verzeichnis]"
    fi
    cd "$ServerPfad"
    AktuellerPfad="$OLDPWD"
    cd "$AktuellerPfad"
    if ! testpfad "$AktuellerPfad" "$PublicPfad"; then
        AktuellerPfad=$AlterPfad
        cd $AktuellerPfad
        Send "!Unerlaubter Pfad."
        Log "-n [Unerlaubter Pfad]"
    fi
}

function Serverquit {
    Send "Bis denn ..."
}

function Servernews {
    Send ""
    cat $ServerPfad\\text\\news.txt >AUX: <AUX:
    Send ""
}

function Serverhelp {
    Send ""
    cat $ServerPfad\\text\\hilfe.txt >AUX: <AUX:
    Send ""
}

function Serverxhelp {
    Send ""
    cat $ServerPfad\\text\\xhilfe.txt >AUX: <AUX:
    Send ""
}

function Serversearch {
    if testfile "$Commandline"; then
        find "$PublicPfad" -name "$Commandline" -print >AUX: <AUX:
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

# Kleines Mailsystem. verbapp erf„lt els ersten Parameter eine Datei, an
# die es den Inhalt der Environment-Variablen $2 anh„ngt. Mittels eines
# vorangestellten Minuszeichens kann direkt ein String bergeben werden.
# Auf diese Weise wird jegliche Expansion in Mails durch CoSHy verhindert.
# Wird der User nicht gefunden (oder ist der Parameter leer), so wird die
# eigene Mailbox gezeigt.

function Servermail {
    getuser "$UserDatei" "\"$Commandline\""
    MailNummer=$?
    if [ $MailNummer -ne -1 ]; then
        MailDatei=$MailPfad\\$MailNummer.msg
        Line="================================================="
        export Line
        verbapp $MailDatei Line
        Line="Mail von $BenutzerName am `datum`"
        export Line
        verbapp $MailDatei -" " Line
        ret=0;
        while [ $ret -eq 0 ]
        do
            Send "-n >"
            get $TIMEOUT Line
            if [ $? -eq 1 ]; then
                Log "TimeOut"
                Send "TimeOut"
                hangup
                exit 1
            fi
            export Line
            verbapp $MailDatei Line
            ret=$?
        done
        Line="================================================="
        export Line; verbapp $MailDatei Line
    else
        if [ -f $MailPfad\\$UserNummer.msg ]; then
            cat $MailPfad\\$UserNummer.msg >AUX:
            Send ""
        else
            Send "Keine Mails vorhanden."
        fi
    fi
    # Returnwert mittels Kommentar auf 0
}

# Funktion zum L”schen der (eigenen) Mailbox.

function Servermaildel {
    rm $MailPfad\\$UserNummer.msg
}

function Serverdir {
    if testfile "$Commandline"; then
        Send ""
        ls -l $Commandline >AUX: <AUX:
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

function Serverpack {
    if [ "$Commandline" = "lzh" ]; then
        PackExt="lzh"
        PackBef="lzh.ttp a -r"
        PackEnd="\\"
        Send "LZH-Packen eingestellt."
        exit
    fi
    if [ "$Commandline" = "zip" ]; then
        PackExt="zip"
        PackBef="zip.ttp -arp"
        PackEnd=""
        Send "ZIP-Packen eingestellt."
        exit
    fi
    if [ "$Commandline" = "zoo" ]; then
        PackExt="zoo"
        PackBef="zoo.ttp ah//"
        PackEnd=""
        Send "ZOO-Packen eingestellt."
        exit
    fi
}

PackExt="zip"
PackBef="zip.ttp -arp"
PackEnd=""

function Serverget {
    if testfile "$Commandline"; then
        for Name in $Commandline
        do
            if [ -d $Name ]; then
                Send "Verzeichnis angefordert. Starte Packer."
                Log "-n [Packer ($PackExt)]"
                Packe='$PackBef $TempPfad\\TMP.$PackExt $Name$PackEnd'
                eval "$Packe >AUX:"
                mv "$TempPfad\\TMP.$PackExt" "$TempPfad\\$Name.$PackExt"
                Send ""
                Send ""
                if [ $? -eq 0 ]; then
                    upload $TempPfad\\$Name.$PackExt
                else
                    Send "Fehler beim Packen."
                    Log "[Packfehler]"
                fi
                rm $TempPfad\\$Name.$PackExt
            else
                if [ -f $Name ]; then
                    upload "$Name"
                else
                    Send "Datei nicht gefunden."
                    Log "-n [Datei fehlt]"
                fi
            fi
        done
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

# Upload (in Richtung Server) nicht ganz automatisch bearbeiten, und von
# hier nochmal sicherstellen, daž alles ins incoming-Verzeichnis kommt.

function Server**B00000000000000 {
    download -p "$ServerPfad\\pub\\incoming" "$Commandline"
}

# Download (vom Server) nur ber get zulassen und hier abfangen:

function Server**B0100000023be50 {
    Send "Automatisches Download nicht gestattet."
    Befehl=""
    Commandline=""
}

function ServerŠ**B0100000023be50 {
    Send "Automatisches Download nicht gestattet."
    Befehl=""
    Commandline=""
}

function Serverput {
    Send ""
    Send "Upload kann automatisch durchgefuehrt werden."
    Send "Starte an Deinem lokalen Rechner einfach"
    Send "einen Zmodem-Upload. Die Datei landet hier in"
    Send "$ServerPfad\\pub\\incoming\\"
    Send ""
}

function Serverview {
    if testfile "$Commandline"; then
        for Name in $Commandline
        do
            Send ""
            Send "$Name:"
            cat $Name >AUX: <AUX:
            Send ""
        done
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

function Serverviewzip {
    if testfile "$Commandline"; then
        for Name in $Commandline
        do
            zip -v $Name >AUX: <AUX:
        done
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

function Serverviewlzh {
    if testfile "$Commandline"; then
        for Name in $Commandline
        do
            lzh v $Name >AUX: <AUX:
        done
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

function Serverviewzoo {
    if testfile "$Commandline"; then
        for Name in $Commandline
        do
            zoo v $Name >AUX: <AUX:
        done
    else
        Send "!Unerlaubter Dateizugriff"
        Log "-n [Unerlaubte Datei]"
    fi
}

function Serveruser {
    Send "Eingetragene Benutzer:"
    cat $UserDatei >AUX: <AUX:
    Send ""
}

# Passwort „ndern

function Serverpasswd {
    Send ""
    Send "Die Passworteingabe wird nicht angezeigt."
    Send "-n Neues Passwort>"
    if HoleEingabe "-n NeuesPass"; then
        Send ""
        Send "-n nochmal zur Kontrolle>"
        if HoleEingabe "-n NNeuesPass"; then
            Send ""
            if [ "$NeuesPass" = "$NNeuesPass" ]; then
                echo "$NeuesPass" > "$UserPfad\\$UserNummer.p"
                Send "Das neue Passwort wurde eingetragen."
                Log "Passwort eingetragen."
            else
                Send "Verschiedene Passworte?"
                Send "Das Passwort wurde nicht ver„ndert."
                Log "Das Passwort wurde nicht ver„ndert."
            fi
        fi
    fi
}

echo "Gleich gehts los"

# Start des Hauptprogramms

# Hack zur Pfadeinstellung
cd $PublicPfad
cd $ServerPfad
AktuellerPfad=$OLDPWD
cd $AktuellerPfad

# PATH merken und neu setzen
OLDPATH="$PATH"
PATH="$ServerPfad\\bin"
export PATH

# Zeilenenden konvertieren
ctty crcrlf

# Kommunikation starten fr eine Anwahl, 3 erlaube Login-Versuche

function EinBenutzer {
    flush
    StartText
    Send ""
    a=1
    while [ $a -le 3 ]
    do
        if Login; then
            break 2
        fi
        a=`expr $a + 1`
    done
    Send ""
    Send "Ende"
    sleep 1s
    flush
}

# Im Modemberieb wartet die folgende Funktion auf Anrufe und startet
# die Aktionen fr einen Benutzer. In der Warteschleife ist ein Abbruch
# des Servers durch die Taste "q" m”glich.

function WarteSchleife {
    while [ 0 -eq 0 ]
    do

        flush

        send "ATZ0S0=1#B1+FCLASS=6"
        waitfor "OK"
        echo ""


        echo "Warte auf Anruf (Abbruch mit "q")"

# Der Zeittest mit $timcnt ist seltsam, aber so gemacht, weil
# timcnt=`expr $timcnt - 1`
# dummerweise auf die Platte zugreift. Das belastet sogar
# einen TT zu sehr!

        timcnt=""

        while ! carrier
        do
            readkey -v 50m TEST
            if [ "$timcnt" = "+++++++++++++++++++++++++++++++++++++++++++++++" ]; then
                timcnt=""
                if intime 07:00 07:10; then
                    TEST=q
                fi
            else
                timcnt="+$timcnt"
            fi
            if [ "$TEST" = "q" ]; then
                echo ""
                echo "Ok. Ich beende den Serverbetrieb..."
                echo "Es ist jetzt `datum`."
                TEST=""
                exit
            fi
        done

        echo "Carrier erkannt."

        if waitfor -i -t 30s "CONNECT"; then
            if waitfor -i -t 500m "FAX"; then
                Log "[`datum`] FAX erkannt."

                send 'at+flid='\"$MYFAXID\"
                      waitfor OK; sleep 50m
                send 'at+fcr=1'
                        waitfor OK; sleep 50m
                send 'at+fclass=2'
                      waitfor OK; sleep 50m
                send 'at+faa=1'
                      waitfor OK; sleep 500m

                cd c:/office
                faxdrv a
                cd $OLDPWD
                Log "[`datum`] FAXbearbeitung beendet."

            else
                EinBenutzer
            fi
        fi

        hangup
        echo "Aufgelegt."
        flush

    done
    echo ""
}

# Der Unterschied zwischen Modem und Schnittstellen-Betrieb:

if [ $Modem -eq 1 ]; then
    WarteSchleife
else
    EinBenutzer
fi

flush
send "+++ATHZ0S0=0"
waitfor "OK"

echo ""
echo "Server beendet."
echo "" >$Schrott
rm $Schrott

# Pfad restaurieren
PATH="$OLDPATH"
export PATH

exit